home *** CD-ROM | disk | FTP | other *** search
/ Internet Surfer 2.0 / Internet Surfer 2.0 (Wayzata Technology) (1996).iso / pc / text / mac / faqs.351 < prev    next >
Text File  |  1996-02-12  |  29KB  |  627 lines
  1. Frequently Asked Questions (FAQS);faqs.351
  2.  
  3.  
  4.  
  5. ANSWER: You have an old version of Emacs compiled before GCC 2.11c and
  6. you are using the Linux extended filesystem.  Get the new version.
  7.  
  8. QUESTION: Why doesn't Control-Z doesn't work right with Emacs?
  9. QUESTION: Why doesn't job control work in shell mode?
  10.  
  11. ANSWER: You have a really old version of Linux Emacs.  Get the new one.
  12.  
  13.        ===================8<==========>8================
  14.  
  15.  
  16. --
  17. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  18. #    LaBRI              |                        #
  19. #  351 cours de la Liberation    |  e-mail:  corsini@labri.greco-prog.fr    #
  20. #  33405 Talence Cedex         |                        #
  21. #                   |                        #
  22. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23. --
  24.   There will be some sig, once our local net will be reliable.
  25.         Right now I rather stay anonymous.
  26. Xref: bloom-picayune.mit.edu comp.lang.lisp:8749 news.answers:4559
  27. Path: bloom-picayune.mit.edu!enterpoop.mit.edu!spool.mu.edu!uunet!ogicse!das-news.harvard.edu!cantaloupe.srv.cs.cmu.edu!crabapple.srv.cs.cmu.edu!mkant
  28. From: mkant+@cs.cmu.edu (Mark Kantrowitz)
  29. Newsgroups: comp.lang.lisp,news.answers
  30. Subject: FAQ: Lisp Frequently Asked Questions 1/6 [Monthly posting]
  31. Summary: Introductory Matter and Bibliography of Introductions and References
  32. Message-ID: <lisp-faq-1.text_724237235@cs.cmu.edu>
  33. Date: 13 Dec 92 09:01:07 GMT
  34. Article-I.D.: cs.lisp-faq-1.text_724237235
  35. Expires: Tue, 26 Jan 1993 09:00:35 GMT
  36. Sender: news@cs.cmu.edu (Usenet News System)
  37. Reply-To: lisp-faq@think.com
  38. Followup-To: poster
  39. Organization: School of Computer Science, Carnegie Mellon
  40. Lines: 1231
  41. Approved: news-answers-request@MIT.Edu
  42. Supersedes: <lisp-faq-1.text_721645282@cs.cmu.edu>
  43. Nntp-Posting-Host: a.gp.cs.cmu.edu
  44.  
  45. Archive-name: lisp-faq/part1
  46. Last-Modified: Thu Nov  5 19:30:40 1992 by Mark Kantrowitz
  47. Version: 1.27
  48.  
  49. ;;; ****************************************************************
  50. ;;; Answers to Frequently Asked Questions about Lisp ***************
  51. ;;; ****************************************************************
  52. ;;; Written by Mark Kantrowitz and Barry Margolin
  53. ;;; lisp-faq-1.text -- 60654 bytes
  54.  
  55. This post contains Part 1 of the Lisp FAQ.
  56.  
  57. If you think of questions that are appropriate for this FAQ, or would
  58. like to improve an answer, please send email to us at lisp-faq@think.com.
  59.  
  60. Note that the lisp-faq mailing list is for discussion of the content
  61. of the FAQ posting only.  It is not the place to ask questions about Lisp;
  62. use either the common-lisp@ai.sri.com mailing list or the
  63. comp.lang.lisp newsgroup for that.  If a question appears frequently
  64. in one of those forums, it will get added to the FAQ list.
  65.  
  66. There are currently six parts to the Lisp FAQ:
  67.    1. Introductory Matter and Bibliography of Introductions and References
  68.    2. General Questions
  69.    3. Common Programming Pitfalls
  70.    4. Lisp/Scheme Implementations and Mailing Lists
  71.    5. CLOS and PCL Questions
  72.    6. FTP Archives and Resources
  73. All parts are posted to comp.lang.lisp. Part 4 is cross-posted to the
  74. comp.lang.scheme newsgroup. Part 5 is cross-posted to the
  75. comp.lang.clos newsgroup.
  76.  
  77. Topics Covered (Part 1):
  78.  
  79.   [1-0]   What is the purpose of this newsgroup?
  80.   [1-1]   What documentation is available on Lisp? How can I learn Lisp?
  81.   [1-2]   How can I improve my Lisp programming style and coding efficiency?
  82.   [1-3]   Where can I learn about implementing Lisp interpreters and compilers?
  83.   [1-4]   What does CLOS, PCL, X3J13, CAR, CDR, ... mean?
  84.   [1-5]   Where can I get a copy of the draft ANSI standard for Common Lisp?
  85.   [1-6]   Lisp Job Postings
  86.  
  87. Topics Covered (Part 2):
  88.  
  89.   [2-1]   Is there a GNU-Emacs interface to Lisp?
  90.   [2-3]   What is the equivalent of EXPLODE and IMPLODE in Common Lisp?
  91.   [2-4]   Is Lisp inherently slower than more conventional languages such as C?
  92.   [2-5]   Why does Common Lisp have "#'"?
  93.   [2-6]   How do I call non-Lisp functions from Lisp?
  94.   [2-7]   Can I call Lisp functions from other languages?
  95.   [2-8]   I want to call a function in a package that might not exist at
  96.           compile time. How do I do this?
  97.   [2-9]   What is CDR-coding?
  98.   [2-10]  What is garbage collection?
  99.   [2-11]  How do I save an executable image of my loaded Lisp system?
  100.           How do I run a Unix command in my Lisp?
  101.           How do I get the current directory name from within a Lisp program?
  102.   [2-12]  I'm porting some code from a Symbolics Lisp machine to some
  103.           other platform, and there are strange characters in the code.
  104.           What do they mean?
  105.   [2-13]  History: Where did Lisp come from?
  106.   [2-14]  How do I find the argument list of a function?
  107.           How do I get the function name from a function object?
  108.   [2-15]  How can I have two Lisp processes communicate via unix sockets?
  109.  
  110. Common Pitfalls (Part 3):
  111.  
  112.   [3-0]  Why does (READ-FROM-STRING "foobar" :START 3) return FOOBAR
  113.          instead of BAR?
  114.   [3-1]  Why can't it deduce from (READ-FROM-STRING "foobar" :START 3)
  115.          that the intent is to specify the START keyword parameter
  116.          rather than the EOF-ERROR-P and EOF-VALUE optional parameters?
  117.   [3-2]  Why can't I apply #'AND and #'OR?
  118.   [3-3]  I used a destructive function (e.g. DELETE, SORT), but it
  119.          didn't seem to work.  Why?
  120.   [3-4]  After I NREVERSE a list, it's only one element long.  After I
  121.          SORT a list, it's missing things.  What happened?
  122.   [3-5]  Why does (READ-LINE) return "" immediately instead of waiting
  123.          for me to type a line?
  124.   [3-6]  I typed a form to the read-eval-print loop, but nothing happened. Why?
  125.   [3-7]  DEFMACRO doesn't seem to work.
  126.          When I compile my file, LISP warns me that my macros are undefined
  127.          functions, or complains "Attempt to call <function> which is
  128.          defined as a macro.
  129.   [3-8]  Name conflict errors are driving me crazy! (EXPORT, packages)
  130.   [3-9]  Closures don't seem to work properly when referring to the
  131.          iteration variable in DOLIST, DOTIMES and DO.
  132.   [3-10] What is the difference between FUNCALL and APPLY?
  133.   [3-11] Miscellaneous things to consider when debugging code.
  134.   [3-12] When is it right to use EVAL?
  135.   [3-13] Why does my program's behavior change each time I use it?
  136.   [3-14] When producing formatted output in Lisp, where should you put the
  137.          newlines (e.g., before or after the line, FRESH-LINE vs TERPRI,
  138.          ~& vs ~% in FORMAT)?
  139.   [3-15] I'm using DO to do some iteration, but it doesn't terminate.
  140.  
  141. Lisp/Scheme Implementations and Mailing Lists (Part 4):
  142.  
  143.   [4-0]   Free Lisp implementations.
  144.   [4-1]   Commercial Lisp implementations.
  145.   [4-2]   Free Scheme implementations.
  146.   [4-3]   Commercial Scheme implementations.
  147.   [4-4]   Other Commercial Lisp-like Language implementations.
  148.   [4-5]   Where can I get an implementation of Prolog in Lisp?
  149.   [4-6]   What is Dylan?
  150.   [4-7]   What Lisp-related discussion groups and mailing lists exist?
  151.   [4-8]   What are R4RS and IEEE P1178?
  152.   [4-9]   How do I do object-oriented programming in Scheme?
  153.  
  154. CLOS Questions (Part 5):
  155.  
  156.   [5-0]   What is CLOS (PCL) and where can I get it?
  157.           How do you pronounce CLOS?
  158.   [5-1]   What documentation is available about object-oriented
  159.           programming in Lisp?
  160.   [5-2]   How I write a function that can access defstruct slots by
  161.           name?  I would like to write something like
  162.           (STRUCTURE-SLOT <object> '<slot-name>).
  163.   [5-3]   How can I list all the CLOS instances in a class?
  164.   [5-4]   How can I store data and CLOS instances (with possibly circular
  165.           references) on disk so that they may be retrieved at some later
  166.           time?
  167.   [5-5]   Given the name of a class, how can I get the names of its slots?
  168.  
  169. FTP Resources (Part 6):
  170.  
  171.   [6-0] General information about FTP Resources for Lisp and Scheme
  172.   [6-1] Repositories of Lisp Software
  173.   [6-2] Repositories of Scheme Software
  174.   [6-3] Publicly Redistributable Lisp Software
  175.   [6-4] Publicly Redistributable Scheme Software
  176.   [6-5] How can I use the X Window System or other GUIs from Lisp?
  177.   [6-6] Formatting code in LaTeX
  178.  
  179. Search for [#] to get to question number # quickly.
  180.  
  181.  
  182. Introduction:
  183.  
  184. Certain questions and topics come up frequently in the various network
  185. discussion groups devoted to and related to Lisp.  This file/article is
  186. an attempt to gather these questions and their answers into a convenient
  187. reference for Lisp programmers.  It (or a reference to it) is posted
  188. periodically.  The hope is that this will cut down on the user time and
  189. network bandwidth used to post, read and respond to the same questions
  190. over and over, as well as providing education by answering questions
  191. some readers may not even have thought to ask.
  192.  
  193. This is not a Lisp tutorial, nor is it an exhaustive list of all Lisp
  194. intricacies.  Lisp is a very powerful and expressive language, but with
  195. that power comes many complexities.  This list attempts to address the
  196. ones that average Lisp programmers are likely to encounter.  If you are
  197. new to Lisp, see the answer to the question "How can I learn Lisp?".
  198.  
  199. The latest version of this file is available via anonymous FTP from CMU
  200. and Thinking Machines:
  201.  
  202.    To obtain the files from CMU, connect by anonymous ftp to any CMU CS
  203.    machine (e.g., ftp.cs.cmu.edu [128.2.206.173]), using username
  204.    "anonymous" and password "name@host". The files lisp-faq-1.text,
  205.    lisp-faq-2.text, lisp-faq-3.text, lisp-faq-4.text, lisp-faq-5.text
  206.    and lisp-faq-6.text are located in the directory
  207.        /afs/cs.cmu.edu/user/mkant/Public/Lisp-Utilities/
  208.    [Note: You must cd to this directory in one atomic operation, as
  209.    some of the superior directories on the path are protected from
  210.    access by anonymous ftp.] If your site runs the Andrew File System,
  211.    you can just cp the files directly without bothering with FTP.
  212.  
  213.    To obtain the files from Thinking Machines, ftp them from ftp.think.com,
  214.    in the directory /public/think/lisp/. The file faq.text contains all the
  215.    parts of the FAQ in one file. In addition, specific versions of the FAQ
  216.    are available as faq-<version>.text.
  217.  
  218. Unless otherwise specified, the Lisp dialect referred to is Common Lisp,
  219. as defined by "Common Lisp: the Language" (aka "CLtL1") as well as
  220. corrections (but not enhancements) from "Common Lisp: the Language, 2nd
  221. Edition" (aka "CLtL2"), both by Guy L. Steele, Jr. and published by
  222. Digital Press. Note that CLtL2 is NOT an official specification for
  223. the language; ANSI Committee X3J13 is preparing such a specification.
  224. See question [1-5] for information on the status of the ANSI
  225. specification for Common Lisp. Enhancements such as CLOS, conditions,
  226. and the LOOP macro will be referred to separately.
  227.  
  228. ----------------------------------------------------------------
  229. [1-0] What is the purpose of this newsgroup?
  230.  
  231. The newsgroup comp.lang.lisp exists for general discussion of
  232. topics related to the programming language Lisp. For example, possible
  233. topics can include (but are not necessarily limited to):
  234.    announcements of Lisp books and products
  235.    discussion of programs and utilities written in Lisp
  236.    discussion of portability issues
  237.    questions about possible bugs in Lisp implementations
  238.    problems porting an implementation to some architecture
  239. Postings should be of general interest to the Lisp community. See also
  240. question [4-7].
  241.  
  242. Questions about object oriented programming in Lisp should be directed
  243. to the newsgroup comp.lang.clos. Similarly, questions about the
  244. programming language Scheme should be directed to the newsgroup
  245. comp.lang.scheme. Discussion of functional programming language issues
  246. should be directed to the newsgroup comp.lang.functional. Discussion
  247. of AI programs implemented in Lisp should sometimes be cross-posted to
  248. the newsgroup comp.ai.
  249.  
  250. ----------------------------------------------------------------
  251. [1-1] What documentation is available on Lisp?
  252.       How can I learn Lisp?
  253.  
  254. There are several good Lisp introductions and tutorials:
  255.  
  256.    1. David S. Touretzky
  257.       "Common Lisp: A Gentle Introduction to Symbolic Computation"
  258.       Benjamin/Cummings Publishers, 1990. 384 pages.
  259.            Perhaps the best tutorial introduction to the language. It has
  260.            clear and correct explanations, and covers some fairly advanced
  261.            topics. The book is an updated Common Lisp version of the 1984
  262.            edition published by Harper and Row Publishers.
  263.  
  264.            Three free Lisp educational tools which were used in the book --
  265.            Evaltrace, DTRACE and SDRAW -- are available by anonymous ftp from
  266.            b.gp.cs.cmu.edu:/usr/dst/public/{lisp,evaltrace}. Evaltrace is a
  267.            graphical notation for explaining how evaluation works and is
  268.            described in "Visualizing Evaluation in Applicative Languages" by
  269.            David S.  Touretzky and Peter Lee, CACM 45-59, October 1992. DTRACE
  270.            is a "detailed trace" which provides more information than the
  271.            tracing tools provided with most Common Lisp implementations. SDRAW
  272.            is a program that draws cons cell structures both for X11 and ascii
  273.            terminals.
  274.  
  275.    2. Robert Wilensky
  276.       "Common LISPcraft"
  277.       W. W. Norton, 1986. 385 pages.
  278.  
  279.    3. Wade L. Hennessey
  280.       "Common Lisp"
  281.       McGraw-Hill, 1989. 395 pages.
  282.            Fairly good, but jumps back and forth from the simple to the
  283.            complex rather quickly, with no clear progression in difficulty.
  284.  
  285.    4. Laurent Siklossy
  286.       "Let's Talk LISP"
  287.       Prentice-Hall, NJ, 1976. 237 pages.
  288.            Good introduction, but quite out of date.
  289.  
  290.    5. Stuart C. Shapiro
  291.       "Common Lisp: An Interactive Approach"
  292.       Computer Science Press/W.H. Freeman, New York, 1992.
  293.       ISBN 0-7167-8218-9
  294.  
  295. Other introductions to Lisp include:
  296.  
  297.    1. A. A. Berk.
  298.       "LISP, The Language of Artificial Intelligence"
  299.       Van Nostrand Reinhold, 1985. 160 pages.
  300.  
  301.    2. Paul Y. Gloess.
  302.       "An Alfred handy guide to Understanding LISP"
  303.       Alfred Publishers (Sherman Oaks, CA), 1982. 64 pages.
  304.  
  305.    3. Ward D. Maurer.
  306.       "The Programmer's Introduction to LISP"
  307.       American Elsevier, 1972. 112 pages.
  308.  
  309.    4. Hank Bromley and Richard Lamson.
  310.       "LISP Lore: A Guide to Programming the LISP Machine"
  311.       Kluwer Academic (Boston), 1987. 337 pages.
  312.  
  313.    5. Sharam Hekmatpour.
  314.       "Introduction to LISP and Symbol Manipulation"
  315.       Prentice Hall (New York), 1988. 303 pages.
  316.  
  317.    6. Deborah G. Tatar
  318.       "A programmer's guide to Common Lisp"
  319.       Digital Press, 1987. 327 pages. ISBN 0-932376-87-8.
  320.            Good introduction on Common Lisp.
  321.  
  322.    7. Timothy Koschmann
  323.       "The Common Lisp Companion"
  324.       John Wiley & Sons, 1990.
  325.        Targeted for those with some programming experience who wish to
  326.        learn draft-ANSI Common Lisp, including CLOS and the CL condition
  327.        system. Examples progress incrementally from simple numerical
  328.        calculation all the way to a logic-programming extension to CL.
  329.  
  330. More advanced introductions to Lisp and its use in Artificial
  331. Intelligence include:
  332.  
  333.    1. Peter Norvig.
  334.       "Paradigms of AI Programming: Case Studies in Common Lisp"
  335.       Morgan Kaufmann, 1992. 946 pages. ISBN 1-55860-191-0.
  336.  
  337.         Provides an in-depth exposition of advanced AI programming techniques
  338.         and includes large-scale detailed examples. The book is the most
  339.         advanced AI/Common-Lisp programming text and reference currently
  340.         available, and hence is not for the complete novice.  It focuses on the
  341.         programming techniques necessary for building large AI systems,
  342.         including object-oriented programming, and has a strong performance
  343.         orientation.
  344.  
  345.         The text is marked by its use of "non-toy" examples to illustrate the
  346.         techniques. All of the examples are written in Common Lisp, and copies
  347.         of the source code are available by anonymous ftp from
  348.         unix.sri.com:pub/norvig and on disk in Macintosh or DOS format from
  349.         the publisher. Some of the techniques described include rule-based
  350.         pattern matching (GPS, Eliza, a subset of Macsyma, the Emycin expert
  351.         system shell), constraint propagation and backtracking (Waltz
  352.         line-labelling), alpha-beta search (Othello), natural language
  353.         processing (top-down, bottom-up and chart parsing), logic-programming
  354.         (unification and Prolog), interpreters and compilers for Scheme, and
  355.         object-oriented programming (CLOS).
  356.  
  357.         The examples are also used to illustrate good programming style and
  358.         efficiency. There is a guide to trouble-shooting and debugging Lisp
  359.         programs, a style guide, and a discussion of portability problems.
  360.         Some of the efficiency techniques described include memoization,
  361.         data indexing, compilation, delaying computation, proper use of
  362.         declarations, avoiding garbage collection, and choosing and using the
  363.         correct data structure.
  364.  
  365.         The book also serves as an advanced introduction to Common Lisp, with
  366.         sections on the Loop macro, CLOS and sequences, and some coverage of
  367.         error handling, series, and the package facility.
  368.  
  369.    2. Eugene Charniak, Christopher K. Riesbeck, Drew V. McDermott
  370.       and James R. Meehan.
  371.       "Artificial Intelligence Programming", 2nd edition.
  372.       Lawrence Erlbaum Associates (Hillsdale, NJ), 1987. 533 pages.
  373.            Provides many nice code fragments, all of which are written
  374.            in Common Lisp. The first half of the book covers topics
  375.            like macros, the reader, data structures, control structures,
  376.            and defstructs. The second half of the book describes
  377.            programming techniques specific to AI, such as
  378.            discrimination nets, production systems, deductive database
  379.            retrieval, logic programming, and truth maintenance.
  380.  
  381.    3. Patrick H. Winston and Berthold K. P. Horn.
  382.       "LISP", 3rd edition.
  383.       Addison-Wesley (Reading, MA), 1989. 611 pages. ISBN 0-201-08319-1
  384.            Covers the basic concepts of the language, but also gives a lot
  385.            of detail about programming AI topics such as rule-based expert
  386.            systems, forward chaining, interpreting transition trees,
  387.            compiling transition trees and finding patterns in images. Not
  388.            a tutorial. Has many good examples.
  389.  
  390.    4. Rodney A. Brooks.
  391.       "Programming in Common Lisp"
  392.       Wiley, 1985. 303 pages.
  393.  
  394.    5. John R. Anderson, Albert T. Corbett, and Brian J. Reiser.
  395.       "Essential LISP"
  396.       Addison-Wesley (Reading, MA), 1987. 352 pages.
  397.            Concentrates on how to use Lisp with iteration and recursion.
  398.  
  399.    6. Robert D. Cameron and Anthony H. Dixon
  400.       "Symbolic Computing with Lisp"
  401.       Prentice-Hall, 1992, 326 pages. ISBN 0-13-877846-9.
  402.            The book is intended primarily as a third-year computer science
  403.            text. In terms of programming techniques, it emphasizes recursion
  404.            and induction, data abstraction, grammar-based definition of Lisp
  405.            data structures and functional programming style. It uses
  406.            two Lisp languages:
  407.                 (1) a purely functional subset of Lisp called Small Lisp and
  408.                 (2) Common Lisp.
  409.            An MS-DOS interpreter for Small Lisp (including source) is
  410.            provided with the book.  It considers applications of Lisp
  411.            to formal symbolic data domains: algebraic expressions,
  412.            logical formulas, grammars and programming languages.
  413.  
  414.    7. Hasemer and Domingue.
  415.       "Common Lisp Programming for Artificial Intelligence"
  416.       Addison-Wesley, 1989.
  417.  
  418.    8. Steven Tanimoto
  419.       "The Elements of Artificial Intelligence: An Introduction Using Lisp"
  420.       Computer Science Press, Rockville, MD, 1987, 530 pages.
  421.  
  422.    9. Patrick R. Harrison
  423.       "Common Lisp and Artificial Intelligence"
  424.       Prentice Hall, 1990. ISBN 0-13-155243
  425.  
  426.   10. Rajeev Sangal
  427.       "Programming Paradigms in Lisp"
  428.       McGraw-Hill, 1991. ISBN 0-07-054666-5.
  429.  
  430. General Lisp reference books include:
  431.  
  432.    1. Guy L. Steele
  433.       "Common Lisp: The Language" [CLtL1]
  434.       Digital Press, 1984. 465 pages. ISBN 0-932376-41-X.
  435.  
  436.    2. Guy L. Steele
  437.       "Common Lisp: The Language, 2nd Edition" [CLtL2]
  438.       Digital Press, 1990. 1029 pages. ISBN 1-55558-041-6.
  439.  
  440.    3. Franz Inc.
  441.       "Common Lisp: The Reference"
  442.       Addison-Wesley, Reading, MA 1988. ISBN 0-201-11458-5
  443.            Entries on lisp functions in alphabetical order.
  444.  
  445.    4. K. Dybvig.
  446.       "The Scheme programming language"
  447.       Prentice Hall, 1987.
  448.          Good reference for Scheme.
  449.  
  450. Lisp periodicals include:
  451.  
  452.    1. LISP Pointers.
  453.       Published by ACM SIGPLAN six times a year. Volume 1, Number 1
  454.       was April-May 1987.
  455.  
  456.    2. LISP and Symbolic Computation, Kluwer Academic Press. Volume 1
  457.       was published in 1989. (jlz@lucid.com is the editor).  ISSN 0892-4635.
  458.       Subscriptions: Institutions $169; Individuals $80. Add $8 for
  459.       air mail. Kluwer Academic Publishers, PO Box 322, 3300 AH Dordrecht,
  460.       The Netherlands, or Kluwer Academic Publishers, PO Box 358, Accord
  461.       Station, Hingham, MA 02018-0358.
  462.  
  463.    3. Proceedings of the biannual ACM Lisp and Functional Programming
  464.       Conference. (First one was in 1980.)
  465.  
  466.    4. Proceedings of the annual Lisp Users and Vendors Conference.
  467.  
  468. Implementation-specific questions:
  469.  
  470.    1. Lucid. See the wizards.doc file that comes with the Lucid
  471.    release. It describes functions, macros, variables and constants that
  472.    are not official parts of the product and are not supported.
  473.    Constructs described in this file include: the interrupt facility, the
  474.    source file recording facility, the resource facility, multitasking,
  475.    writing your own streams, lisp pipes, i/o buffers, the compiler,
  476.    floating-point functions, memory management, debugger information, the
  477.    window tool kit, extensions to the editor, the foreign function
  478.    interface, clos information, delivery toolkit information, and Lucid
  479.    lisp training classes. The wizards.doc file also covers i/o
  480.    constructs, functions for dealing with DEFSTRUCT, functions and
  481.    constants for dealing with procedure objects, functions and constants
  482.    for dealing with code objects, function for mapping objects,
  483.    additional keyword argument to DISKSAVE, function used in the
  484.    implementation of arrays, function for monitor-specific behavior for a
  485.    process, additional keyword argument to RUN-PROGRAM, and load-time
  486.    evaluation.
  487.  
  488. Introductions to Scheme (Many books on Scheme are worth reading
  489. even if you use Common Lisp, because many of the issues are similar):
  490.  
  491.    1. Harold Abelson and Gerald Jay Sussman, with Julie Sussman.
  492.       "Structure and Interpretation of Computer Programs"
  493.       MIT Press (Cambridge, MA) and McGraw-Hill (New York), 1985.
  494.       542 pages. ISBN 0-262-01077-1
  495.            Starts off introductory, but rapidly gets into powerful
  496.            Lisp-particular constructs, such as using closures and
  497.            engines, building interpreters, compilers and
  498.            object-oriented systems.
  499.  
  500.    2. Daniel P. Friedman and M. Felleisen.
  501.       "The Little LISPer"
  502.       MIT Press (Cambridge, MA), 3rd printing, 1989. ISBN 0-262-56038-0.
  503.       Science Research Associates (Chicago), 3rd ed, 1989. 206 pages.
  504.            Good for a quick introduction. Uses Scheme instead of
  505.            Common Lisp.  (The book uses a dialect of Scheme with
  506.            footnotes about translating to Scheme or Common Lisp. The
  507.            footnotes won't allow a non-expert to use Common Lisp for
  508.            the advanced chapters because of the complexity.)
  509.  
  510.    3. George Springer and Daniel P. Friedman
  511.       "Scheme and the Art of Programming"
  512.       MIT Press and McGraw Hill, 1990, 596 pages.
  513.            Introduces basic concepts of programming in Scheme. Also deals
  514.            with object oriented programming, co-routining, continuations.
  515.            Gives numerous examples.
  516.  
  517.    4. Wolfgang Kreutzer and Bruce McKenzie
  518.       "Programming for Artificial Intelligence:
  519.        Methods, Tools and Applications"
  520.       Addison-Wesley (Reading, MA), 1990. 682 pages.
  521.       ISBN 0-201-41621-2.
  522.            Discusses Scheme, Prolog, and Smalltalk, gives an overview of
  523.            the history and philosophy of AI, surveys three major
  524.            programming paradigms (procedural, declarative, and
  525.            object-oriented), and metaphors to AI programming.
  526.  
  527.    5. Smith
  528.       "Introduction to Scheme"
  529.        1988.
  530.            Focuses on PC Scheme.
  531.  
  532.    6. Michael Eisenberg
  533.       "Programming in Scheme"
  534.       Scientific Press (Redwood City, CA), 1988. 304 pages.
  535.  
  536.    7. The Ken Dickey article, "The Scheme Programming Language", in
  537.       COMPUTER LANGUAGES magazine, and the Revised^4 Report on the
  538.       Algorithmic Language Scheme, both of which are available by anonymous
  539.       ftp from the scheme archive at nexus.yorku.ca.
  540.  
  541.    8. Two articles in BYTE Magazine, February 1988, by Abelson and
  542.       Sussman, and Clinger.
  543.  
  544.    9. The Info files from the MIT Scheme implementation.
  545.  
  546. Special Topics:
  547.  
  548.    Garbage Collection:
  549.  
  550.       Wilson, Paul R., "Uniprocessor Garbage Collection Techniques"
  551.       Proceedings of the 1992 International Workshop on Memory Management.
  552.       Surveys garbage collection techniques. Available by anonymous ftp from
  553.       cs.utexas.edu:pub/garbage/gcsurvey.ps. Contact wilson@cs.utexas.edu
  554.       for more info.
  555.  
  556. ----------------------------------------------------------------
  557. [1-2] How can I improve my Lisp programming style and coding efficiency?
  558.  
  559. There are several books about Lisp programming style, including:
  560.  
  561.    1. Molly M. Miller and Eric Benson
  562.       "Lisp Style and Design"
  563.       Digital Press, 1990. 214 pages. ISBN 1-55558-044-0.
  564.            How to write large Lisp programs and improve Lisp programming
  565.            style. Uses the development of Lucid CL as an example.
  566.  
  567.    2. Robin Jones, Clive Maynard, and Ian Stewart.
  568.       "The Art of Lisp Programming"
  569.       Springer-Verlag, 1989. 169 pages.
  570.  
  571.    3. W. Richard Stark.
  572.       "LISP, Lore, and Logic: an algebraic view of LISP
  573.        programming, foundations, and applications"
  574.       Springer-Verlag, 1990. 278 pages. ISBN 0-387-97072-X
  575.            Self-modifying code, self-reproducing programs, etc.
  576.  
  577.    4. CMU CL User's Manual, Chapter 7, (talks about writing
  578.       efficient code). It is available by anonymous ftp from any CMU CS
  579.       machine (e.g., ftp.cs.cmu.edu [128.2.206.173]) as the file
  580.         /afs/cs.cmu.edu/project/clisp/docs/cmu-user/cmu-user.ps
  581.       [when getting this file by anonymous ftp, one must cd to
  582.       the directory in one atomic operation, as some of the superior
  583.       directories on the path are protected from access by anonymous ftp.]
  584.  
  585.    5. See also Norvig's book, SICP (Abelson & Sussman), SAP
  586.       (Springer and Friedman).
  587.  
  588.    6. Hallvard Tretteberg's Lisp Style Guide is available by anonymous
  589.       ftp in ftp.think.com:/public/think/lisp/style-guide.text. There is
  590.       a fair bit of overlap between Hallvard's style guide and the notes
  591.       below and in part 3 of this FAQ.
  592.  
  593. Here are some general suggestions/notes about improving Lisp
  594. programming style, readability, correctness and efficiency:
  595.  
  596.    General Programming Style Rules:
  597.  
  598.       - Write short functions, where each function provides a single,
  599.         well-defined operation. Small functions are easier to
  600.         read, write, test, debug, and understand.
  601.  
  602.       - Use descriptive variable and function names. If it isn't clear
  603.         from the name of a function or variable what its purpose is,
  604.         document it with a documentation string and a comment. In fact,
  605.         even if the purpose is evident from the name, it is still worth
  606.         documenting your code.
  607.  
  608.       - Don't write Pascal (or C) code in Lisp. Use the appropriate
  609.         predefined functions -- look in the index to CLtL2, or use the
  610.         APROPOS and DESCRIBE functions. Don't put a close parenthesis
  611.         on a line by itself -- this can really aggravate programmers
  612.         who grew up on Lisp. Lisp-oriented text editors include tools
  613.         for ensuring balanced parentheses and for moving across
  614.         pairs of balanced parentheses.
  615.  
  616.       - Use proper indentation -- you should be able to understand
  617.         the structure of your definitions without noticing the parentheses.
  618.  
  619.    The following functions often abused or misunderstood by novices.
  620.    Think twice before using any of these functions.
  621.  
  622.       - EVAL. Novices almost always misuse EVAL. When experts use
  623.         EVAL, they often would be better off using APPLY, FUNCALL, or
  624.         SYMBOL-VALUE. Use of EVAL when defining a macro should set off
  625.         a warning bell -- macro definitions are already evaluated
  626.         during expansion. See also the answer to question 3-12.
  627.